// src/services/users.js - 用户管理服务

import { get, post, put, del, uploadFile, fetchWithRetry } from './api';
import {
  getUser as localGetUser,
  getUserStats as localGetUserStats,
  getUserTorrents as localGetUserTorrents,
  getUserInviteCodes as localGetUserInviteCodes,
  generateInviteCode as localGenerateInviteCode,
  deleteInviteCode as localDeleteInviteCode,
  validateInviteCodeDetail as localValidateInviteCodeDetail,
  getAllTorrents as localGetAllTorrents,
  saveInviteCode as localSaveInviteCode
} from '../utils/localStorage';
import { formatFileSize } from '../utils/formatUtils';

/**
 * 获取当前用户信息
 * @returns {Promise} - 用户信息
 */
export const getCurrentUserInfo = async () => {
  try {
    const response = await get('/user/auth/me');

    // 处理后端响应
    if (response && response.code === 200) {
      return {
        success: true,
        data: response.data
      };
    } else {
      return {
        success: false,
        message: response.message || '获取用户信息失败',
        error: {
          code: response.code
        }
      };
    }
  } catch (error) {
    console.warn('获取用户信息API连接失败，使用本地存储:', error);

    // 从localStorage获取用户信息
    const user = localGetUser();

    if (!user) {
      throw new Error('用户未登录或会话已过期');
    }

    return {
      success: true,
      data: {
        user: {
          ...user,
          // 不返回敏感信息
          password: undefined
        }
      }
    };
  }
};

/**
 * 获取用户信息（目前后端只实现了获取当前用户的信息）
 * @param {string} username - 用户名
 * @returns {Promise} - 用户信息
 */
export const getUserInfo = async (username) => {
  try {
    // 注意：后端尚未实现按用户名获取用户信息的接口
    // 目前只能获取当前登录用户的信息
    return await getCurrentUserInfo();
    // const response = await get(`/users/${username}`);
    // if (response && response.code === 200) {
    //   return {
    //     success: true,
    //     data: response.data
    //   };
    // } else {
    //   return {
    //     success: false,
    //     message: response.message || '获取用户信息失败',
    //     error: {
    //       code: response.code
    //     }
    //   };
    // }
  } catch (error) {
    console.warn('获取用户信息API连接失败，使用本地存储:', error);

    // 从localStorage获取用户信息
    const user = localGetUser();

    if (!user || (username && user.username !== username)) {
      throw new Error('用户不存在或无权访问');
    }

    return {
      success: true,
      data: {
        user: {
          ...user,
          // 不返回敏感信息
          password: undefined
        }
      }
    };
  }
};

/**
 * 通过用户名获取用户ID（用于管理员操作）
 * @param {string} username - 用户名
 * @returns {Promise} - 用户ID
 */
export const getUserIdByUsername = async (username) => {
  try {
    // 后端有 getUserByUsername 方法，但需要特定的API端点
    // 暂时使用简单的数字转换作为临时解决方案
    // 如果用户名是数字格式，直接返回
    const numericId = parseInt(username);
    if (!isNaN(numericId) && numericId > 0) {
      return {
        success: true,
        data: { userId: numericId }
      };
    }

    // 如果用户名不是数字，尝试从已知映射中查找
    // 这是一个临时的解决方案，实际应该调用后端API
    const userMapping = {
      'admin': 1,
      'charlie': 2,
      'alice': 3,
      'bob': 4,
      'test': 5,
      'helper_user': 6,
      'tech_expert': 7
    };

    const userId = userMapping[username];
    if (userId) {
      return {
        success: true,
        data: { userId: userId }
      };
    }

    // 如果都没找到，返回错误
    return {
      success: false,
      message: `无法找到用户名 ${username} 对应的用户ID`
    };
  } catch (error) {
    console.error('获取用户ID失败:', error);
    return {
      success: false,
      message: '获取用户ID失败: ' + error.message
    };
  }
};

/**
 * 获取用户统计数据
 * @param {string} username - 用户名
 * @returns {Promise} - 用户统计数据
 */
export const getUserStats = async (username) => {
  try {
    // 注意：后端尚未实现按用户名获取用户统计数据的专门接口
    // 用户统计数据包含在 /user/auth/me 接口中
    const userInfo = await getCurrentUserInfo();
    //尝试修改接口连接，后端实现后可尝试调整
    //const userInfo = await get(`/users/${username}/stats`);

    if (userInfo.success && userInfo.data?.user) {
      // 从用户信息中提取统计数据
      const user = userInfo.data.user;

      // 计算分享率：上传量÷下载量
      const uploadCountRaw = user.uploadCount || 0;
      const downloadCountRaw = user.downloadCount || 0;

      let calculatedRatio = 0;
      if (downloadCountRaw === 0) {
        // 下载量为0时，如果有上传量则显示为无穷大，否则为0
        calculatedRatio = uploadCountRaw > 0 ? 999.99 : 0;
      } else {
        calculatedRatio = uploadCountRaw / downloadCountRaw;
      }

      // 用户统计数据已经包含在用户信息中
      return {
        success: true,
        data: {
          stats: {
            uploadCount: formatFileSize(uploadCountRaw),
            downloadCount: formatFileSize(downloadCountRaw),
            uploadCountRaw: uploadCountRaw,
            downloadCountRaw: downloadCountRaw,
            ratio: calculatedRatio,  // 前端计算的分享率
            // 其他统计信息可能需要从其他接口获取
            uploadedTorrents: 0,  // 暂未提供
            downloadedTorrents: 0, // 暂未提供
            registerDays: 0, // 需要计算
            lastActive: new Date().toISOString() // 暂未提供
          }
        }
      };
    } else {
      return userInfo; // 返回错误信息
    }
  } catch (error) {
    console.warn('获取用户统计数据API连接失败，使用本地存储:', error);

    // 从localStorage获取用户信息
    const user = localGetUser();

    if (!user || (username && user.username !== username)) {
      throw new Error('用户不存在或无权访问');
    }

    // 本地获取用户上传的种子
    const uploadedTorrents = localGetUserTorrents(user.username);

    // 计算用户注册天数
    const registerDate = new Date(user.registerDate);
    const today = new Date();
    const registerDays = Math.floor((today - registerDate) / (1000 * 60 * 60 * 24));

    // 计算本地存储的分享率
    const localUploadCountRaw = user.uploadCount || 0;
    const localDownloadCountRaw = user.downloadCount || 0;

    let localCalculatedRatio = 0;
    if (localDownloadCountRaw === 0) {
      // 下载量为0时，如果有上传量则显示为无穷大，否则为0
      localCalculatedRatio = localUploadCountRaw > 0 ? 999.99 : 0;
    } else {
      localCalculatedRatio = localUploadCountRaw / localDownloadCountRaw;
    }

    return {
      success: true,
      data: {
        stats: {
          uploadCount: formatFileSize(localUploadCountRaw),
          downloadCount: formatFileSize(localDownloadCountRaw),
          ratio: localCalculatedRatio,  // 前端计算的分享率
          uploadedTorrents: uploadedTorrents.length,
          downloadedTorrents: 0, // 本地存储中没有专门记录下载历史
          registerDays: registerDays,
          lastActive: new Date().toISOString() // 模拟当前时间为最后活动时间
        }
      }
    };
  }
};

/**
 * 获取用户上传的种子
 * @param {string} username - 用户名 (暂时不使用，后端接口获取当前用户的上传)
 * @param {Object} params - 查询参数 (page, limit)
 * @returns {Promise} - 用户上传的种子列表
 */
export const getUserUploads = async (username, params = {}) => {
  // 时间格式化函数（相对时间显示）
  const formatTime = (timeString) => {
    if (!timeString) return '未知时间';

    try {
      const date = new Date(timeString);

      // 检查日期是否有效
      if (isNaN(date.getTime())) {
        return '时间格式错误';
      }

      const now = new Date();
      const diffMs = now.getTime() - date.getTime();
      const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
      const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
      const diffMinutes = Math.floor(diffMs / (1000 * 60));

      // 相对时间显示
      if (diffMinutes < 60) {
        return diffMinutes <= 0 ? '刚刚' : `${diffMinutes}分钟前`;
      } else if (diffHours < 24) {
        return `${diffHours}小时前`;
      } else if (diffDays < 7) {
        return `${diffDays}天前`;
      } else if (diffDays < 30) {
        const weeks = Math.floor(diffDays / 7);
        return `${weeks}周前`;
      } else if (diffDays < 365) {
        const months = Math.floor(diffDays / 30);
        return `${months}个月前`;
      } else {
        const years = Math.floor(diffDays / 365);
        return `${years}年前`;
      }
    } catch (error) {
      console.warn('时间格式化失败:', timeString, error);
      return '时间解析失败';
    }
  };

  // 格式化完整日期时间（用于详情显示）
  const formatFullDateTime = (timeString) => {
    if (!timeString) return '未知时间';

    try {
      const date = new Date(timeString);

      if (isNaN(date.getTime())) {
        return '时间格式错误';
      }

      const year = date.getFullYear();
      const month = String(date.getMonth() + 1).padStart(2, '0');
      const day = String(date.getDate()).padStart(2, '0');
      const hours = String(date.getHours()).padStart(2, '0');
      const minutes = String(date.getMinutes()).padStart(2, '0');

      return `${year}年${month}月${day}日 ${hours}:${minutes}`;
    } catch (error) {
      console.warn('完整时间格式化失败:', timeString, error);
      return '时间解析失败';
    }
  };

  try {
    // 调用后端API获取用户上传的种子
    const response = await get('/user/upload/torrents');
    console.log('用户上传种子API响应:', response);

    if (response && response.code === 200) {
      // 处理后端返回的数据格式
      const uploadedTorrents = response.data || [];

      // 数据适配：根据后端实际返回的字段进行正确映射
      const adaptedTorrents = uploadedTorrents.map((torrent, index) => ({
        id: torrent.id || `upload_${index}`,
        title: torrent.name || '未命名种子',                    // 后端使用 name 字段
        name: torrent.name || '未命名种子',
        category: torrent.classification || '未分类',            // 分类使用 classification 字段
        size: formatFileSize(torrent.size || 0),                // 后端直接使用 size 字段(字节)
        sizeInBytes: torrent.size || 0,                         // 原始字节数用于排序
        uploadDate: torrent.fileTimestamps || new Date().toISOString(), // 时间戳字段
        uploader: username || 'unknown',
        seeders: torrent.seeder || 0,                           // 做种数字段名
        leechers: 0,                                            // 后端暂未提供
        downloads: torrent.download || 0,                       // 下载数字段名
        views: torrent.watchs || 0,                             // 浏览数字段名
        promotion: torrent.category || 'none',                  // 促销类型使用 category 字段

        // 格式化时间显示
        formattedUploadDate: formatTime(torrent.fileTimestamps),
        fullUploadDateTime: formatFullDateTime(torrent.fileTimestamps),
        rawUploadDate: torrent.fileTimestamps || new Date().toISOString()
      }));

      // 简单的客户端分页
      const page = params.page || 1;
      const limit = params.limit || 20;
      const start = (page - 1) * limit;
      const end = start + limit;
      const paginatedTorrents = adaptedTorrents.slice(start, end);

      return {
        success: true,
        data: {
          torrents: paginatedTorrents,
          total: adaptedTorrents.length,
          page: page,
          limit: limit
        }
      };
    } else {
      return {
        success: false,
        message: response.message || '获取用户上传种子失败',
        error: {
          code: response.code || 500
        }
      };
    }
  } catch (error) {
    console.warn('获取用户上传种子API连接失败，使用本地存储回退:', error);

    // 从localStorage获取用户上传的种子
    const torrents = localGetUserTorrents(username);

    // 简单的客户端分页
    const page = params.page || 1;
    const limit = params.limit || 20;
    const start = (page - 1) * limit;
    const end = start + limit;
    const paginatedTorrents = torrents.slice(start, end);

    return {
      success: true,
      data: {
        torrents: paginatedTorrents,
        total: torrents.length,
        page: page,
        limit: limit,
        isLocalStorage: true
      }
    };
  }
};

/**
 * 获取用户下载历史
 * @returns {Promise} - 用户下载历史
 */
export const getUserDownloads = async () => {
  try {
    const response = await get(`/user/download/history`);
    console.log('下载历史API响应:', response);

    if (response && response.code === 200) {
      return {
        success: true,
        data: response.data
      };
    } else {
      return {
        success: false,
        message: response.message || '获取下载历史失败',
        error: {
          code: response.code || 500
        }
      };
    }
  } catch (error) {
    console.warn('获取用户下载历史失败:', error);

    // 根据错误类型返回不同的状态码
    let errorCode = 500;
    if (error.response) {
      errorCode = error.response.status;
    } else if (error.message && error.message.includes('Network Error')) {
      errorCode = 503; // 服务不可用
    }

    return {
      success: false,
      message: '获取下载历史失败',
      error: {
        code: errorCode,
        details: error.message || '未知错误'
      }
    };
  }
};

/**
 * 生成邀请码
 * @returns {Promise} - 生成结果
 */
export const generateInviteCode = async () => {
  try {
    // 先生成本地邀请码对象以备用
    const generateResult = localGenerateInviteCode();
    if (!generateResult.success) {
      return {
        success: false,
        message: generateResult.message || '生成邀请码失败'
      };
    }

    // 从生成结果中提取邀请码
    const inviteCode = generateResult.inviteCode;
    const code = inviteCode.code;

    try {
      // 将生成的邀请码发送到后端存储
      // 后端期望的参数格式是 { code: string }
      const response = await post('/invites/generate', { code });

      // 处理后端响应
      if (response && response.code === 200) {
        return {
          success: true,
          message: response.message || '邀请码生成成功',
          data: {
            inviteCode: inviteCode
          }
        };
      } else {
        // 后端返回错误，但不抛出异常，直接返回错误信息
        return {
          success: false,
          message: response.message || '邀请码生成失败',
          error: {
            code: response.code
          }
        };
      }
    } catch (apiError) {
      // API调用出错，回退到本地存储
      console.warn('邀请码API连接失败，使用本地存储:', apiError);

      const saveResult = localSaveInviteCode(generateResult.inviteCode);
      if (!saveResult.success) {
        return {
          success: false,
          message: saveResult.message || '存储邀请码失败'
        };
      }

      return {
        success: true,
        message: '邀请码生成成功（本地模式）',
        data: {
          inviteCode: generateResult.inviteCode
        }
      };
    }
  } catch (error) {
    console.error('生成邀请码过程出错:', error);
    return {
      success: false,
      message: error.message || '生成邀请码失败'
    };
  }
};

/**
 * 获取用户邀请码列表
 * @returns {Promise} - 用户邀请码列表
 */
export const getUserInviteCodes = async () => {
  try {
    // 调用后端API获取用户自己的邀请码
    const response = await get('/invites/own');

    // 处理后端响应
    if (response && response.code === 200) {
      return {
        success: true,
        data: response.data
      };
    } else {
      // 后端API失败，回退到本地存储
      console.warn('获取邀请码API失败，使用本地存储:', response);

      const inviteCodes = localGetUserInviteCodes();
      return {
        success: true,
        data: {
          inviteCodes
        }
      };
    }
  } catch (error) {
    console.warn('获取邀请码API连接失败，使用本地存储:', error);

    // 使用localStorage获取用户邀请码
    const inviteCodes = localGetUserInviteCodes();

    return {
      success: true,
      data: {
        inviteCodes
      }
    };
  }
};

/**
 * 删除邀请码
 * @param {string} code - 邀请码
 * @returns {Promise} - 删除结果
 */
export const deleteInviteCode = async (code) => {
  try {
    // 调用后端API删除邀请码
    const response = await post(`/invites/delete/${code}`);

    // 处理后端响应
    if (response && response.code === 200) {
      return {
        success: true,
        message: response.message || '邀请码删除成功'
      };
    } else {
      // 后端API失败，回退到本地存储
      console.warn('删除邀请码API失败，使用本地存储:', response);

      const result = localDeleteInviteCode(code);
      return {
        success: result.success,
        message: result.message || (result.success ? '邀请码删除成功' : '邀请码删除失败')
      };
    }
  } catch (error) {
    console.warn('删除邀请码API连接失败，使用本地存储:', error);

    // 使用localStorage删除邀请码
    const result = localDeleteInviteCode(code);

    return {
      success: result.success,
      message: result.message || (result.success ? '邀请码删除成功' : '删除邀请码失败')
    };
  }
};

/**
 * 更新用户密码
 * @param {string} oldPassword - 旧密码
 * @param {string} newPassword - 新密码
 * @returns {Promise} - 更新结果
 */
export const updatePassword = async (oldPassword, newPassword) => {
  try {
    // 注意：后端尚未实现修改密码的接口
    // 这里将来需要调用后端API，例如:
    const response = await post('/user/auth/alter', { oldPassword, newPassword });
    return response;

    // 暂时抛出错误，以便回退到本地存储
    throw new Error('API尚未实现');
  } catch (error) {
    console.warn('更新密码API连接失败或API尚未实现，使用本地存储:', error);

    // 从localStorage获取当前用户
    const currentUser = localGetUser();
    if (!currentUser) {
      throw new Error('用户未登录或会话已过期');
    }

    // 获取所有用户
    const usersStr = localStorage.getItem('starrypt_users');
    const users = usersStr ? JSON.parse(usersStr) : [];

    // 找到当前用户
    const userIndex = users.findIndex(u => u.username === currentUser.username);
    if (userIndex === -1) {
      throw new Error('用户不存在');
    }

    // 验证旧密码
    if (users[userIndex].password !== oldPassword) {
      throw new Error('当前密码错误');
    }

    // 更新密码
    users[userIndex].password = newPassword;
    localStorage.setItem('starrypt_users', JSON.stringify(users));

    return {
      success: true,
      message: '密码修改成功',
      data: null
    };
  }
};

/**
 * 获取话题所有成员（用于管理员搜索）
 * @param {number} topicId - 话题ID 
 * @returns {Promise} - 话题成员列表
 */
export const getTopicAllUsers = async (topicId) => {
  try {
    const response = await get(`/user/all/${topicId}`);

    // 适配后端响应格式 {code: 200, message: "操作成功", data: [...]}
    if (response.code === 200) {
      return {
        success: true,
        data: response.data || []
      };
    } else {
      return {
        success: false,
        message: response.message || '获取话题成员失败',
        data: []
      };
    }
  } catch (error) {
    console.warn('获取话题成员API连接失败:', error);

    // 回退机制：返回空列表或基础测试数据
    return {
      success: false,
      message: '获取话题成员失败: ' + error.message,
      data: []
    };
  }
};

/**
 * 获取用户个人中心统计数据
 * @returns {Promise} - 用户个人中心统计数据
 */
export const getUserProfileStats = async () => {
  try {
    console.log('🔄 正在调用 /user/auth/me 接口获取用户统计数据...');
    const response = await get('/user/auth/me');

    console.log('📡 /user/auth/me 接口原始响应:', response);

    // 处理后端响应
    if (response && response.code === 200) {
      const user = response.data.user;
      console.log('👤 后端用户数据:', user);

      // 格式化数据为前端期望的格式
      const uploadVolumeRaw = user.uploadCount || 0;
      const downloadVolumeRaw = user.downloadCount || 0;

      // 前端计算分享率：上传量÷下载量（不再依赖后端ratio字段）
      // 当下载量为0时：有上传量显示为∞(999.99)，无上传量显示为0
      let calculatedShareRatio = 0;
      if (downloadVolumeRaw === 0) {
        calculatedShareRatio = uploadVolumeRaw > 0 ? 999.99 : 0;
      } else {
        calculatedShareRatio = uploadVolumeRaw / downloadVolumeRaw;
      }

      const profileStats = {
        magicValue: user.magic || 0,                    // 魔力值
        shareRatio: calculatedShareRatio,               // 分享率(前端计算：上传量÷下载量)
        uploadVolume: formatFileSize(uploadVolumeRaw),  // 上传量(字节转换为可读格式)
        downloadVolume: formatFileSize(downloadVolumeRaw), // 下载量(字节转换为可读格式)
        uploadVolumeRaw: uploadVolumeRaw,               // 原始上传量(字节)
        downloadVolumeRaw: downloadVolumeRaw,           // 原始下载量(字节)
        registerDays: user.registerDate || 0,           // 注册天数
        seedCount: user.seeds || 0,                     // 种子数量(修正字段名：seeds)
        userId: user.id || 0,                           // 用户ID
        username: user.username || '',                  // 用户名
        email: user.email || '',                        // 邮箱
        role: user.role || 'user',                      // 用户角色
        signed: user.signed || false                    // 今日是否已签到
      };

      console.log('✅ 格式化后的用户统计数据:', profileStats);

      return {
        success: true,
        data: profileStats
      };
    } else {
      console.error('❌ 后端API返回错误:', response);
      return {
        success: false,
        message: response.message || '获取用户统计数据失败',
        error: {
          code: response.code
        }
      };
    }
  } catch (error) {
    console.warn('⚠️ 获取用户统计数据API连接失败，使用本地存储:', error);

    // 从localStorage获取用户统计数据
    const currentUser = JSON.parse(localStorage.getItem('starrypt_user') || '{}');
    if (!currentUser.username) {
      throw new Error('用户未登录');
    }

    // 计算本地存储的分享率
    const localUploadVolumeRaw = currentUser.uploadCount || 0;
    const localDownloadVolumeRaw = currentUser.downloadCount || 0;

    let localCalculatedShareRatio = 0;
    if (localDownloadVolumeRaw === 0) {
      // 下载量为0时，如果有上传量则显示为无穷大，否则为0
      localCalculatedShareRatio = localUploadVolumeRaw > 0 ? 999.99 : 0;
    } else {
      localCalculatedShareRatio = localUploadVolumeRaw / localDownloadVolumeRaw;
    }

    const fallbackStats = {
      magicValue: currentUser.magic || 0,
      shareRatio: localCalculatedShareRatio,  // 前端计算：上传量÷下载量
      uploadVolume: formatFileSize(localUploadVolumeRaw),
      downloadVolume: formatFileSize(localDownloadVolumeRaw),
      uploadVolumeRaw: localUploadVolumeRaw,
      downloadVolumeRaw: localDownloadVolumeRaw,
      registerDays: Math.floor((new Date() - new Date(currentUser.registerDate || new Date())) / (1000 * 60 * 60 * 24)),
      seedCount: 0,
      userId: currentUser.id || 0,
      username: currentUser.username || '',
      email: currentUser.email || '',
      role: currentUser.role || 'user'
    };

    console.log('🔄 使用本地存储回退数据:', fallbackStats);

    return {
      success: true,
      data: fallbackStats
    };
  }
};

/**
 * 根据分类获取种子列表
 * @param {string} classification - 种子分类（如：电影、电视剧、动漫等）
 * @returns {Promise} - 分类种子列表
 */
export const getTorrentsByClassification = async (classification) => {
  // 时间格式化函数（相对时间显示）
  const formatTime = (timeString) => {
    if (!timeString) return '未知时间';

    try {
      const date = new Date(timeString);

      // 检查日期是否有效
      if (isNaN(date.getTime())) {
        return '时间格式错误';
      }

      const now = new Date();
      const diffMs = now.getTime() - date.getTime();
      const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
      const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
      const diffMinutes = Math.floor(diffMs / (1000 * 60));

      // 相对时间显示
      if (diffMinutes < 60) {
        return diffMinutes <= 0 ? '刚刚' : `${diffMinutes}分钟前`;
      } else if (diffHours < 24) {
        return `${diffHours}小时前`;
      } else if (diffDays < 7) {
        return `${diffDays}天前`;
      } else if (diffDays < 30) {
        const weeks = Math.floor(diffDays / 7);
        return `${weeks}周前`;
      } else if (diffDays < 365) {
        const months = Math.floor(diffDays / 30);
        return `${months}个月前`;
      } else {
        const years = Math.floor(diffDays / 365);
        return `${years}年前`;
      }
    } catch (error) {
      console.warn('时间格式化失败:', timeString, error);
      return '时间解析失败';
    }
  };

  // 格式化完整日期时间（用于详情显示）
  const formatFullDateTime = (timeString) => {
    if (!timeString) return '未知时间';

    try {
      const date = new Date(timeString);

      if (isNaN(date.getTime())) {
        return '时间格式错误';
      }

      const year = date.getFullYear();
      const month = String(date.getMonth() + 1).padStart(2, '0');
      const day = String(date.getDate()).padStart(2, '0');
      const hours = String(date.getHours()).padStart(2, '0');
      const minutes = String(date.getMinutes()).padStart(2, '0');

      return `${year}年${month}月${day}日 ${hours}:${minutes}`;
    } catch (error) {
      console.warn('完整时间格式化失败:', timeString, error);
      return '时间解析失败';
    }
  };

  try {
    console.log('🔍 正在调用分类筛选接口:', `/user/torrents/classify/${classification}`);

    // 对分类名称进行URL编码，支持中文
    const encodedClassification = encodeURIComponent(classification);
    const response = await get(`/user/torrents/classify/${encodedClassification}`);

    console.log('📊 分类筛选API响应:', response);

    if (response && response.code === 200) {
      // 处理后端返回的数据格式
      const classificationTorrents = response.data || [];

      // 数据适配：根据后端实际返回的字段进行正确映射
      const adaptedTorrents = classificationTorrents.map((torrent, index) => ({
        id: torrent.id || `classify_${classification}_${index}`,
        title: torrent.name || '未命名种子',                    // 后端使用 name 字段
        name: torrent.name || '未命名种子',
        category: torrent.classification || classification,      // 分类使用 classification 字段
        classification: torrent.classification || classification,
        size: formatFileSize(torrent.size || 0),                // 后端直接使用 size 字段(字节)
        sizeInBytes: torrent.size || 0,                         // 原始字节数用于排序
        uploadDate: torrent.fileTimestamps || new Date().toISOString(), // 时间戳字段
        uploader: torrent.uploader || 'unknown',
        seeders: torrent.seeder || 0,                           // 做种数字段名
        leechers: 0,                                            // 后端暂未提供
        downloads: torrent.download || 0,                       // 下载数字段名
        views: torrent.watchs || 0,                             // 浏览数字段名
        upvotes: torrent.upvote || 0,                           // 点赞数
        promotion: torrent.category || 'none',                  // 促销类型使用 category 字段
        // 添加前端组件需要的字段
        description: torrent.comment || '暂无描述',              // 描述使用 comment 字段
        tags: [],                                               // 后端暂未提供tags
        coverImage: torrent.presource || 'https://via.placeholder.com/300x450', // 封面图片
        torrentUrl: torrent.tresource || null,                  // 种子文件路径
        hash: torrent.hash || null,
        files: [],                                              // 后端暂未提供文件列表


        // 格式化时间显示
        formattedUploadDate: formatTime(torrent.fileTimestamps),
        fullUploadDateTime: formatFullDateTime(torrent.fileTimestamps),
        rawUploadDate: torrent.fileTimestamps || new Date().toISOString()
      }));

      console.log(`✅ 成功获取 "${classification}" 分类的 ${adaptedTorrents.length} 个种子`);

      return {
        success: true,
        data: {
          torrents: adaptedTorrents,
          total: adaptedTorrents.length,
          classification: classification
        }
      };
    } else {
      return {
        success: false,
        message: response.message || `获取 "${classification}" 分类种子失败`,
        error: {
          code: response.code || 500
        }
      };
    }
  } catch (error) {
    console.warn(`⚠️ 获取 "${classification}" 分类种子API连接失败:`, error);

    // 返回错误信息，让调用方决定是否回退
    return {
      success: false,
      message: `获取 "${classification}" 分类种子失败: ${error.message}`,
      error: {
        code: 503,
        details: error.message || '网络连接失败'
      }
    };
  }
};

/**
 * 魔力值兑换上传量
 * @param {number} magicToExchange - 要兑换的魔力值数量
 * @returns {Promise} - 兑换结果
 */
export const exchangeMagicForUpload = async (magicToExchange) => {
  try {
    console.log('🔄 正在调用魔力值兑换接口，兑换魔力值:', magicToExchange);

    // 参数验证
    if (!magicToExchange || magicToExchange <= 0) {
      return {
        success: false,
        message: '兑换的魔力值必须大于0'
      };
    }

    // 改为POST请求，使用application/x-www-form-urlencoded格式
    // 这是Spring Boot @RequestParam最常用的格式
    const params = new URLSearchParams();
    params.append('magicToExchange', magicToExchange.toString());

    const response = await fetchWithRetry('/oss/exchange', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
      },
      body: params.toString()
    });
    console.log('📡 魔力值兑换API响应:', response);

    // 处理后端响应格式 {code: 200, message: "操作成功", data: {...}}
    if (response && response.code === 200) {
      return {
        success: true,
        message: response.message || '魔力值兑换成功',
        data: {
          magicUsed: magicToExchange,
          uploadGained: response.data?.uploadGained || 0,
          newMagicBalance: response.data?.newMagicBalance || 0,
          newUploadVolume: response.data?.newUploadVolume || 0,
          exchangeRate: response.data?.exchangeRate || '1:1',
          timestamp: new Date().toISOString()
        }
      };
    } else {
      return {
        success: false,
        message: response.message || '魔力值兑换失败',
        error: {
          code: response.code || 500,
          details: response.message
        }
      };
    }
  } catch (error) {
    console.error('❌ 魔力值兑换API调用失败:', error);

    // 错误处理 - 检查不同的错误类型
    let errorMessage = '魔力值兑换失败';
    let errorCode = 500;

    if (error.response) {
      errorCode = error.response.status;
      if (errorCode === 400) {
        errorMessage = '兑换参数无效或魔力值不足';
      } else if (errorCode === 401) {
        errorMessage = '用户未登录，请先登录';
      } else if (errorCode === 403) {
        errorMessage = '权限不足，无法进行兑换操作';
      } else if (errorCode === 404) {
        errorMessage = '兑换接口暂未开放';
      } else if (errorCode >= 500) {
        errorMessage = '服务器错误，请稍后重试';
      }
    } else if (error.message && error.message.includes('Network Error')) {
      errorCode = 503;
      errorMessage = '网络连接失败，请检查网络后重试';
    }

    return {
      success: false,
      message: errorMessage,
      error: {
        code: errorCode,
        details: error.message || '未知错误'
      }
    };
  }
};

export default {
  getUserInfo,
  getCurrentUserInfo,
  getUserIdByUsername,
  getUserStats,
  getUserUploads,
  getUserDownloads,
  generateInviteCode,
  getUserInviteCodes,
  deleteInviteCode,
  updatePassword,
  getTopicAllUsers,
  getUserProfileStats,
  getTorrentsByClassification,
  exchangeMagicForUpload
}; 